home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (68k).sea / pro Fit 5.0 demo (68k) / Notes / pro Fit binary data file format / pro Fit binary data file format
Encoding:
Text File  |  1996-07-20  |  5.7 KB  |  160 lines  |  [TEXT/MPCC]
  1. pro Fit Binary Data File Format
  2.  
  3. -----------------------------------------------------------------
  4.  
  5. Changed 19.7.96: Corrected some inaccuracies in the description
  6.                  of the column info data.
  7.                  Added information about some optional entries
  8.                  in the resource fork.
  9.  
  10. -----------------------------------------------------------------
  11.  
  12.  
  13.  
  14.  
  15. The following is a description of the native binary format that
  16. pro Fit 5.0 uses for data files. You may use this format if
  17. you want to exchange large data sets between pro Fit and an
  18. application of your own.
  19. For smaller data sets, it may be easier to use text files.
  20.  
  21.  
  22. You can use this information in any way you want. Note, however,
  23. that future versions of pro Fit might use different file formats.
  24.  
  25.  
  26. If you are interested in exchanging binary data with pro Fit through
  27. the clipboard and with drag and drop, you can also obtain a copy
  28. of the specifications of the format we use on the scrap. Contact us
  29. at profit@cherwell.com
  30.  
  31.  
  32.  
  33. Warning: you will need some experience in programming to understand
  34. what follows.
  35.  
  36.  
  37. Type/Creator:
  38. -------------
  39.  
  40. The type of data files is 'ftLS'
  41. The creator of pro Fit files is 'NLft' 
  42.  
  43.  
  44.  
  45. Data fork:
  46. ----------
  47.  
  48. The data in the data fork starts with a 5 byte header looking like this:
  49.   Bytes 0-3: 'NLft'  (hex 0x4E, 0x4C, 0x66, 0x74)
  50.   Byte 4:     0x0D
  51.  
  52.  
  53. Then, there follow the names of the columns, separated by tabulators (0x09).
  54. After the names, there follows a carriage return (0x0D).
  55.  
  56.  
  57. After the names, there follows a series of arrays data blocks. Each
  58. data block is preceded by a long integer (4 byte), called the "type" that says what kind
  59. of data is to follow. type can take the values of -1 (if column information
  60. follows), 4 if a column of 4-byte float values follows, 8 if a column of 8 byte
  61. double values follows, or 1 if a string column follows. 
  62.  
  63. The first data block contains column information and has a type -1. The following
  64. data block contain the data for columns 1, 2, 3, etc. They can have type 1, 4 or 8.
  65.  
  66. A data block with column information has type -1 (column information)
  67. and looks as follows:
  68.  4 bytes:    type (= -1)
  69.  4 bytes:    size (long integer) This gives the size in bytes of 
  70.              the "column info data" that follows.
  71.  size bytes: the "column info data"
  72.  The "column info data" is an array where each element describes the format of
  73.  one column. Each element looks like this:
  74.  
  75.      typedef struct
  76.     {    unsigned char t;    // the type of the column:
  77.                             //   0 if 4 byte floating point
  78.                             //   1 if 8 byte floating point
  79.                             // 128 if text column
  80.         unsigned char n;    // additional info, depending on value above, by default always set to 0
  81.                             // for numeric cols:    bits0-3: the number of decimals +1 (0: auto)
  82.                             //                        bit7: 1 if scientific, 0 else
  83.         unsigned char width;// the width of this column divided by 2, 0 if default width
  84.         unsigned char x;    // reserved
  85.     } ColType;
  86.  
  87. The entries in the "column info data" array define the format of columns 1, 2, 3, etc.
  88. The first entry defines the format of column 1.
  89.  
  90. The following are the data blocks for column data:
  91.  
  92. If type is 4 (4 byte floating point column)
  93.  4 bytes:    type (4)
  94.  4 bytes:    size (long integer) This gives the number of floating point values in the column. 
  95.  4*size bytes: the column data, an array of 4 byte floating point numbers.
  96.  
  97. If type is 8 (8 byte floating point column)
  98.  4 bytes:    type (8)
  99.  4 bytes:    size (long integer) This gives the number of floating point values in the column. 
  100.  8*size bytes: the column data, an array of 8 byte floating point numbers.
  101.  
  102. If type is 1 (string column)
  103.  4 bytes:    type (=1)
  104.  4 bytes:    size (long integer) The number of bytes in the following "column data". 
  105.  size bytes: "column data".
  106. The column data is a record that looks as follows:
  107.     typedef struct                            // the data structure of a column of strings
  108.     {    long        size;                    // the size in bytes of this record 
  109.         long        nrRows;                    // the number of rows of this column 
  110.         long        firstOffset;            // set to 14 
  111.         short        firstRow;                // set to 1 
  112.         unsigned char    data[MANY];            // here follow the strings (pascal strings), packed, one after another 
  113.     } StringData;
  114. The strings in "data" must be pascal strings, each containing exactly as many characters
  115. it requires. There are no gaps between the strings.
  116. Note: All the above records use 68k-struct alignments. This matterls in the
  117. StringData struct: "data" is at an offset of 14 bytes from the beginning of the
  118. record.
  119.  
  120. To learn more, look at the data fork with a file editor.
  121.  
  122.  
  123.  
  124.  
  125.  
  126. The resource fork
  127. -----------------
  128.  
  129. The resource fork holds some optional data. When writing a file, you don't have to
  130. generate the resources unless you want to override the default values.
  131. The following is a list of the most important entries:
  132.  
  133. Type = 'fINF', ID = 128:
  134. This resource contains the text that appears in the info-field. The text must consist
  135. of 1-byte roman characters. The length of the resource defines the length of the text.
  136.  
  137. Type = 'fINF', ID = 129:
  138. An entry of type "Rect" (8 bytes) with the global coordinates where the window is to
  139. appear.
  140.  
  141. Type = 'fINF', ID = 130:
  142. Information about the font, font size and font style to be used in the window.
  143. bytes 0 and 1:    reserved
  144. bytes 2 and 3:    short size (must be between 3 and 48 for data windows)
  145. byte 4:            the font style (ignored for data windows)
  146. byte 5:            reserved
  147. bytes 6,7,etc:    a Pascal string with the font's name
  148.  
  149. Type = 'fINF', ID = 131:
  150. 4 long integer values (totally 16 bytes). The interpretation of these values if different for
  151. each window type.
  152. For data windows, the first long integer value (4st for bytes) define the "height" of the
  153. info field at the top of the window. Set it to 0 if you want to hide the info field, other-
  154. wise set it to a value between 16 and 100. Set all other 12 bytes of the resource to 0.
  155.  
  156.  
  157.  
  158.  
  159. Good luck!
  160.